﻿using UnityEngine;
using System.Collections;
using UnityEditor;
using UnityEditor.Animations;
using System.Collections.Generic;
using System.IO;


public static class AssetTool
{
//     public static byte[] SetTextureReadable(string _relativeAssetPath)
//     {
//         AssetImporter assetImporter = TextureImporter.GetAtPath(_relativeAssetPath);
//         if(assetImporter == null)
//         {
//             return null;
//         }

//         byte[] metaContent = CommonUtil.fileToBytes(_relativeAssetPath + ".meta");

//         if(assetImporter is TextureImporter)
//         {
//             TextureImporter ti = (TextureImporter)assetImporter;
//             string[] p = new string[]{"Android", "iPhone", "Standalone"};
//             for(int i = 0; i < p.Length; i++)
//             {
//                 TempTextureFormat androidFormat = new TempTextureFormat();
//                 bool ret = ti.GetPlatformTextureSettings(p[i], out androidFormat.maxSize, out androidFormat.format, out androidFormat.quality);
//                 if(ret)
//                 {
//                     ti.ClearPlatformTextureSettings(p[i]);
//                 }
//             }

//             ti.textureCompression = TextureImporterCompression.Uncompressed;
//             ti.isReadable = true;

//             if (ti.textureType == TextureImporterType.NormalMap)
//             {
//                 ti.textureType = TextureImporterType.Default;
//             }

//             ti.SaveAndReimport();
//         }
//         else if(assetImporter is IHVImageFormatImporter)
//         {
//             IHVImageFormatImporter ti = (IHVImageFormatImporter)assetImporter;
//             ti.isReadable = true;
//             ti.SaveAndReimport();
//         }

//         return metaContent;
//     }

//     public static void ReverseTextureReadable(string _relativeAssetPath, byte[] oldMetaContent)
//     {
//         if(oldMetaContent == null)
//         {
//             return;
//         }

//         CommonUtil.bytesToFile(_relativeAssetPath + ".meta", oldMetaContent);
//     }

//     public static bool HasAlpha(this Texture2D tex)
//     {
//         if(tex == null)
//         {
//             return false;
//         }

//         bool isAlpha = false;
//         TextureFormat format = tex.format;
//         return isAlphaTextureFormat(format);
//     }

//     public static bool isAlphaTextureFormat(TextureFormat format)
//     {
//         bool isAlpha = false;
//         switch (format)
//         {
//             case TextureFormat.ARGB32:
//             case TextureFormat.RGBA32:
//             case TextureFormat.BGRA32:
//             case TextureFormat.RGBA4444:
//             case TextureFormat.ARGB4444:
//             case TextureFormat.PVRTC_RGBA4:
//             case TextureFormat.PVRTC_RGBA2:
//             case TextureFormat.ETC2_RGBA8:
//             case TextureFormat.ETC2_RGBA1:
//             case TextureFormat.DXT5:
//             case TextureFormat.DXT5Crunched:
//                 isAlpha = true;
//                 break;
//         }

//         return isAlpha;
//     }

    public static int GetTextureSize(this Texture tex)
    {
        int pixelBit = tex.GetTexturePixelBitNum();
        float t = tex.height;
        t *= tex.width;
        t *= pixelBit;
        return Mathf.CeilToInt(t / (float)8);
    }

    public static int GetTexturePixelBitNum(this Texture tex)
    {
        if (tex == null)
        {
            return 0;
        }

        TextureFormat f = TextureFormat.YUY2;
        if (tex is Texture2D)
        {
            f = (tex as Texture2D).format;
        }
        else if (tex is Texture3D)
        {
            f = (tex as Texture3D).format;
        }
        else if (tex is Cubemap)
        {
            f = (tex as Cubemap).format;
        }

        int bitNum = 0;
        switch (f)
        {
            case TextureFormat.RGBAFloat:
                bitNum = 128;
                break;

            case TextureFormat.RGBAHalf:
                bitNum = 64;
                break;

            case TextureFormat.RFloat:
            case TextureFormat.RGB9e5Float:
            case TextureFormat.RG16:
            case TextureFormat.ARGB32:
            case TextureFormat.RGBA32:
            case TextureFormat.BGRA32:
                bitNum = 32;
                break;

            case TextureFormat.RGB24:
            case TextureFormat.RGB565:
                bitNum = 24;
                break;

            case TextureFormat.RHalf:
            case TextureFormat.R16:
            case TextureFormat.RGBA4444:
            case TextureFormat.ARGB4444:
                bitNum = 16;
                break;

            case TextureFormat.DXT5:
            case TextureFormat.ETC2_RGBA8:
            case TextureFormat.Alpha8:
            case TextureFormat.R8:
                bitNum = 8;
                break;

            case TextureFormat.DXT1:
            case TextureFormat.PVRTC_RGBA4:
            case TextureFormat.PVRTC_RGB4:
            case TextureFormat.ETC_RGB4:
            case TextureFormat.ETC2_RGB:
                bitNum = 4;
                break;

            case TextureFormat.PVRTC_RGBA2:
            case TextureFormat.PVRTC_RGB2:
                bitNum = 2;
                break;

            case TextureFormat.ETC2_RGBA1:
                bitNum = 5;
                break;
        }

        if (bitNum == 0)
        {
            throw new System.Exception("GetTexturePixelBitNum failed: " + AssetDatabase.GetAssetPath(tex) + "  " + tex.name + "  " + f);
        }

        return bitNum;
    }

//     [MenuItem("Assets/Custom/Texture/ConvertPsdDdsTiffTgaToJpgOrPng")]
//     public static void ConvertPsdDdsTiffOrToJpgOrPng()
//     {
//         System.Action<string> searchCallback = (texPath) =>
//             {

//                 Texture2D tex = AssetDatabase.LoadAssetAtPath<Texture2D>(texPath);
//                 if(tex == null) {return;}

//                 bool isAlpha = tex.HasAlpha();

//                 if (isAlpha)
//                 {
//                     ConvertToPngOrJpg(texPath, true);
//                 }
//                 else
//                 {
//                     ConvertToJpg2(texPath);
//                 }
//             };

//         EditorCommonTool.ProcessSelectionObjs("*.psd", searchCallback);
//         AssetDatabase.Refresh();

//         string dirPath = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
//         if (!System.IO.Directory.Exists(dirPath))
//         {
//             return;
//         }

//         EditorCommonTool.ProcessSelectionObjs("*.dds", searchCallback);
//         AssetDatabase.Refresh();
//         EditorCommonTool.ProcessSelectionObjs("*.tga", searchCallback);
//         AssetDatabase.Refresh();
//         EditorCommonTool.ProcessSelectionObjs("*.TGA", searchCallback);
//         AssetDatabase.Refresh();
//         EditorCommonTool.ProcessSelectionObjs("*.tif*", searchCallback);
//         AssetDatabase.Refresh();
//     }

//     [MenuItem("Assets/Custom/Texture/NoAlphaPngToJpg")]
//     public static void NoAlphaPngToJpg()
//     {
//         System.Action<string> searchCallback = (texPath) =>
//             {
//                 TextureImporter textureImporter = AssetImporter.GetAtPath(texPath) as TextureImporter;
//                 TextureImporterPlatformSettings settings = textureImporter.GetPlatformTextureSettings("Android");
//                 if(settings.format == TextureImporterFormat.ETC2_RGB4 || settings.format == TextureImporterFormat.ETC_RGB4)
//                 {
//                     ConvertToJpg2(texPath);
//                 }
//             };

//         EditorCommonTool.ProcessSelectionObjs("*.png", searchCallback);
//         AssetDatabase.Refresh();
//     }

//     public static Color GetPixel(Color[] pixels, int width, int height, int x, int y)
//     {
//         return pixels[x + y * width];
//     }

//     public static Color GetLinearPixel(Color[] pixels, int width, int height, float x, float y)
//     {
//         int x0 = Mathf.FloorToInt(x);
//         int x1 = Mathf.CeilToInt(x);
//         int y0 = Mathf.FloorToInt(y);
//         int y1 = Mathf.CeilToInt(y);

//         Color pixel00 = GetPixel(pixels, width, height, x0, y0);
//         Color pixel01 = GetPixel(pixels, width, height, x0, y1);
//         Color pixel11 = GetPixel(pixels, width, height, x1, y1);
//         Color pixel10 = GetPixel(pixels, width, height, x1, y0);

//         float tx = x - x0;
//         float ty = y - y0;

//         Color pixel0 = (1 - tx) * pixel00 + tx * pixel01;
//         Color pixel1 = (1 - tx) * pixel10 + tx * pixel11;
//         Color pixel = (1 - ty) * pixel0 + ty * pixel1;
//         return pixel;
//     }

//     public static Color GetAveragePixel(Color[] pixels, int width, int height, int x, int y, float tileWidth, float tileHeight)
//     {
//         Color sum = Color.black;
//         sum.a = 0;
//         int pixelNum = 0;
//         for (float i = 0; i < tileWidth; i++)
//         {
//             for (float j = 0; j < tileHeight; j++)
//             {
//                 float realX = x * tileWidth + i;
//                 float realY = y * tileHeight + j;
//                 Color c = GetLinearPixel(pixels, width, height, realX, realY);
//                 sum += c;
//                 pixelNum++;
//             }
//         }

//         sum /= pixelNum;
//         return sum;
//     }

//     public static Color[] Scale(Color[] pixels, int width, int height, int newWidth, int newHeight)
//     {
//         float tileWidth = width / newWidth;
//         float tileHeight = height / newHeight;

//         Color[] newPixels = new Color[newWidth * newHeight];
//         for (int i = 0; i < newWidth; i++)
//         {
//             for (int j = 0; j < newHeight; j++)
//             {
//                 newPixels[i + j * newWidth] = GetAveragePixel(pixels, width, height, i, j, tileWidth, tileHeight);
//             }
//         }
//         return newPixels;
//     }

//     public static string ConvertToPngOrJpg(string texPath, bool png, string destPath = null, int destWidth = 0, int destHeight = 0, bool setReadable = true, bool copyMeta = true)
//     {
//         byte[] temp = null;
//         if (setReadable)
//         {
//             temp = SetTextureReadable(texPath);
//         }
//         TextureImporter importer = TextureImporter.GetAtPath(texPath) as TextureImporter;
//         bool hasAlpha = importer.DoesSourceTextureHaveAlpha();
//         Texture2D tex = AssetDatabase.LoadAssetAtPath(texPath, typeof(Texture2D)) as Texture2D;
//         if (tex == null)
//         {
//             return null;
//         }

//         if (destWidth <= 0)
//         {
//             destWidth = tex.width;
//         }

//         if (destHeight <= 0)
//         {
//             destHeight = tex.height;
//         }

//         if (destWidth != tex.width || destHeight != tex.height)
//         {
//             int oldWidth = tex.width;
//             int oldHeight = tex.height;

//             Color[] pixels = tex.GetPixels();
//             tex.Resize(destWidth, destHeight);

//             Color[] newPixels = Scale(pixels, oldWidth, oldHeight, destWidth, destHeight);
//             tex.SetPixels(newPixels);

//             //          tex = new Texture2D(tex.width, tex.height, tex.format, false);
//             //          tex.SetPixels(oldTex.GetPixels());
//             //          tex.Resize(destWidth, destHeight);
//         }

//         byte[] data = null;
//         try
//         {
//             if(png)
//             {
//                 data = tex.EncodeToPNG();
//             }
//             else
//             {
//                 data = tex.EncodeToJPG(100);
//             }
//         }
//         catch(System.Exception e)
//         {

//         }

//         if (data == null)
//         {
//             Color[] colorData = tex.GetPixels();
//             Texture2D tex2 = new Texture2D(tex.width, tex.height, hasAlpha? TextureFormat.ARGB32: TextureFormat.RGB24, false);
//             tex2.SetPixels(colorData);

//             if(png)
//             {
//                 data = tex.EncodeToPNG();
//             }
//             else
//             {
//                 data = tex.EncodeToJPG(100);
//             }

//             if (data == null)
//             {
//                 return null;
//             }
//         }

//         if (temp != null)
//         {
//             ReverseTextureReadable(texPath, temp);
//         }

//         string ext = ".jpg";
//         if(png)
//         {
//             ext = ".png";
//         }

//         if (destPath != null)
//         {
//             string newPath = System.IO.Path.ChangeExtension(destPath, ext);
//             string newPathDir = System.IO.Path.GetDirectoryName(newPath);
//             if (!System.IO.Directory.Exists(newPathDir))
//             {
//                 CommonUtil.CreateDir(newPathDir);
//             }

//             CommonUtil.bytesToFile(newPath, data);

//             if (copyMeta)
//             {
//                 string oldMetaFilePath = texPath + ".meta";
//                 string newMetaFilePath = newPath + ".meta";
//                 CommonUtil.Copy(oldMetaFilePath, newMetaFilePath);
//             }

//             return newPath;
//         }
//         else
//         {
//             string newPath = System.IO.Path.ChangeExtension(texPath, ext);
//             CommonUtil.bytesToFile(newPath, data);
//             if (copyMeta)
//             {
//                 string oldMetaFilePath = texPath + ".meta";
//                 string newMetaFilePath = newPath + ".meta";
//                 CommonUtil.Move(oldMetaFilePath, newMetaFilePath);
//             }

//             if (texPath != newPath)
//             {
//                 CommonUtil.Delete(texPath);
//             }

//             return newPath;
//         }
//     }


//     public static void ConvertToJpg2(string texPath)
//     {
//         byte[] oldMetaContent = SetTextureReadable(texPath);
//         Texture2D tex = AssetDatabase.LoadAssetAtPath(texPath, typeof(Texture2D)) as Texture2D;
//         if (tex == null)
//         {
//             return;
//         }

//         byte[] data = null;
//         try
//         {
//             tex.EncodeToJPG(100);
//         }
//         catch(System.Exception e)
//         {

//         }

//         if (data == null)
//         {
//             Color[] colorData = tex.GetPixels();
//             Texture2D tex2 = new Texture2D(tex.width, tex.height, TextureFormat.ARGB32, false);
//             tex2.SetPixels(colorData);
//             data = tex2.EncodeToJPG(100);
//             if (data == null)
//             {
//                 return;
//             }
//         }

//         ReverseTextureReadable(texPath, oldMetaContent);

//         string newPath = System.IO.Path.ChangeExtension(texPath, ".jpg");
//         CommonUtil.bytesToFile(newPath, data);

//         if (texPath != newPath)
//         {
//             string oldMetaFilePath = texPath + ".meta";
//             string newMetaFilePath = newPath + ".meta";
//             CommonUtil.Move(oldMetaFilePath, newMetaFilePath);
//             CommonUtil.Delete(texPath);
//         }
//     }

//     [MenuItem("Assets/Custom/Texture/ConvertToJpg")]
//     public static void ConvertToJpg()
//     {
//         for(int i = 0; i < Selection.assetGUIDs.Length; i++)
//         {
//             string texPath = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[i]);
//             ConvertToJpg2(texPath);
//         }
//         AssetDatabase.Refresh();
//     }

//     [MenuItem("Assets/Custom/Texture/ConvertToPng")]
//     public static void ConvertToPng()
//     {
//         for(int i = 0; i < Selection.assetGUIDs.Length; i++)
//         {
//             string texPath = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[i]);
//             ConvertToPngOrJpg(texPath, true);
//         }
//         AssetDatabase.Refresh();
//     }

//     [MenuItem("Custom/Texture/FindMipmapTexture")]
//     public static void FindMipmapTexture()
//     {
//         string log = "";
//         string[] paths = AssetDatabase.FindAssets("t:texture", new string[]{ResourcesEx.BundleResDir});
//         for (int i = 0; i < paths.Length; i++)
//         {
//             paths[i] = AssetDatabase.GUIDToAssetPath(paths[i]);
//             TextureImporter importer = TextureImporter.GetAtPath(paths[i]) as TextureImporter;
//             if (importer != null)
//             {
//                 if (importer.mipmapEnabled)
//                 {
//                     log += "\n" + paths[i];
//                 }
//             }
//             else
//             {
//                 log += "\n" + paths[i] + " no importer";
//             }
//         }

//         Debug.LogError("mipmap textures: " + log);
//     }

    [MenuItem("Custom/AssetTool/ImportNewAsset")]
    public static void ImportNewAsset()
    {
        HashSet<string> modifiedFiles = new HashSet<string>();

        string[] args = System.Environment.GetCommandLineArgs();
        string filePath = null;
        bool all = false;
        for (int i = 0; i < args.Length; i++)
        {
            if (args[i] == "-all")
            {
                all = bool.Parse(args[i + 1]);
                if (all)
                {
                    break;
                }
            }

            if (args[i] == "-diffFile")
            {
                filePath = args[i + 1];
            }

            if (args[i] == "-rebuild")
            {
                string str = args[i + 1];
                if (!string.IsNullOrEmpty(str))
                {
                    string[] modifieds = str.Split(new char[]{ ',' });
                    for (int j = 0; j < modifieds.Length; j++)
                    {
                        modifiedFiles.Add(modifieds[j]);
                    }
                }
            }
        }


        if (all)
        {
            string[] paths = System.IO.Directory.GetFiles("Assets/", "*", SearchOption.AllDirectories);
            for (int i = 0; i < paths.Length; i++)
            {
                string path = paths[i].Replace(".meta", "");
                path = path.Trim();
                modifiedFiles.Add(path);
            }
        }
        else
        {

            string str = CommonUtil.fileToString(filePath);
            if (!string.IsNullOrEmpty(str))
            {
                StringReader reader = new StringReader(str);
                while (true)
                {
                    string line = reader.ReadLine();
                    if (string.IsNullOrEmpty(line))
                    {
                        break;
                    }

                    line = line.Replace(".meta", "");
                    line = line.Trim();
                    modifiedFiles.Add(line);
                }
            }
        }

        Debug.Log("test import new asset: " + modifiedFiles.Count);
        foreach(string modifiedFile in modifiedFiles)
        {
            Debug.Log("test import new asset2: " + modifiedFile);
            ImportAsset(modifiedFile);
        }
    }

    static void ImportAsset(string path)
    {
        string ext = Path.GetExtension(path).ToLower();
        switch (ext)
        {
            //            case ".fbx":
            //            {
            //                ImportFBX(path);
            //            }
            //            break;
            case ".jpg":
            case ".png":
            case ".tga":
            case ".exr":
            case ".psd":
            case ".tif":
            case ".bmp":
                {
                    ImportTexture(path);
                }
                break;
        }
    }

//     static void ImportFBX(string path)
//     {
//         AssetImporter assetImporter = AssetImporter.GetAtPath(path);
//         ModelImporter modelImporter = assetImporter as ModelImporter;
//         bool needSave = false;
//         modelImporter.materialName = Set(modelImporter.materialName, ModelImporterMaterialName.BasedOnMaterialName, ref needSave);
//         if (needSave)
//         {
//             modelImporter.SaveAndReimport();
//         }
//     }

    static void ImportTexture(string assetPath)
    {
        if (assetPath.Contains("/lod/"))
        {
            return;
        }

        if (assetPath.Contains("/art/") || assetPath.Contains("/terrain/"))
        {
            AssetImporter assetImporter = AssetImporter.GetAtPath(assetPath);
            TextureImporter textureimport = (TextureImporter)assetImporter;
            bool needSave = fixTex(textureimport);
            if (needSave)
            {
                textureimport.SaveAndReimport();
            }
        }
        else if (assetPath.Contains("/scene/"))
        {
            AssetImporter assetImporter = AssetImporter.GetAtPath(assetPath);
            TextureImporter textureimport = (TextureImporter)assetImporter;
            bool needSave = fixLightmap(textureimport);
            if (needSave)
            {
                textureimport.SaveAndReimport();
            }
        }

        if (assetPath.Contains(ResourcesEx.BundleResDir + "/tex/"))
        {
            AssetImporter assetImporter = AssetImporter.GetAtPath(assetPath);
            TextureImporter textureimport = (TextureImporter)assetImporter;
            bool needSave = fixUI(textureimport);
            if (needSave)
            {
                textureimport.SaveAndReimport();
            }
        }
    }

    static T Set<T>(T t, T v, ref bool needSave)
    {
        if (!t.Equals(v))
        {
            //          Debug.LogError("need_save_importer_2: " + t + " " + v);
            t = v;
            needSave = true;
        }
        return t;
    }
    static bool fixLightmap(TextureImporter textureimport)
    {
        if (textureimport == null)
        {
            return false;
        }

        bool needSave = false;

        textureimport.mipmapEnabled = Set(textureimport.mipmapEnabled, textureimport.textureType != TextureImporterType.Lightmap && textureimport.textureShape == TextureImporterShape.TextureCube, ref needSave);
        if (textureimport.textureShape == TextureImporterShape.TextureCube)
        {
            textureimport.maxTextureSize = Set(textureimport.maxTextureSize, 256, ref needSave);
        }
        else
        {
            textureimport.maxTextureSize = Set(textureimport.maxTextureSize, 2048, ref needSave);
        }
        return needSave;
    }

    static bool fixTex(TextureImporter textureimport)
    {
        if (textureimport == null)
        {
            return false;
        }

        bool needSave = false;
        TextureImporterType tt = TextureImporterType.Default;
        if (textureimport.assetPath.Contains("_n.") || textureimport.textureType == TextureImporterType.NormalMap)
        {
            tt = TextureImporterType.NormalMap;
        }

        textureimport.textureType = Set(textureimport.textureType, tt, ref needSave);
        textureimport.textureShape = Set(textureimport.textureShape, textureimport.assetPath.EndsWith(".exr")? TextureImporterShape.TextureCube: TextureImporterShape.Texture2D, ref needSave);
        textureimport.sRGBTexture = Set(textureimport.sRGBTexture, tt != TextureImporterType.NormalMap, ref needSave);
        textureimport.alphaSource = Set(textureimport.alphaSource, TextureImporterAlphaSource.FromInput, ref needSave);
        textureimport.alphaIsTransparency = Set(textureimport.alphaIsTransparency, false, ref needSave);
        textureimport.mipmapEnabled = Set(textureimport.mipmapEnabled, textureimport.assetPath.EndsWith(".exr"), ref needSave);
        textureimport.isReadable = Set(textureimport.isReadable, false, ref needSave);
        textureimport.filterMode = Set(textureimport.filterMode, FilterMode.Bilinear, ref needSave);
        //        Debug.LogError("mipmap: " + textureimport.mipmapEnabled + "  " + textureimport.mipMapBias + "  " + textureimport.mipmapFilter + "  " + textureimport.borderMipmap);
        string[] platforms = new string[]{ "iPhone", "Android", "Standalone" };
        for (int i = 0; i < platforms.Length; i++)
        {
            string platform = platforms[i];
            TextureImporterPlatformSettings setting = textureimport.GetPlatformTextureSettings(platform);
            bool newA = false;
            if (setting == null)
            {
                newA = true;
                needSave = true;
                setting = new TextureImporterPlatformSettings();
            }

            setting.overridden = Set(setting.overridden, true, ref needSave);
            int maxTexSize = 512;

            string assetPath = textureimport.assetPath;
            if (assetPath.Contains("art/model/bone/bone1/")
                || assetPath.Contains("art/model/bone/bone2/")
                || assetPath.Contains("art/model/bone/bone3/")
                || assetPath.Contains("art/model/bone/bone4/")
                || assetPath.Contains("art/model/bone/bone5/")
                || assetPath.Contains("art/model/bone/bone6/")
                || assetPath.Contains("art/model/bone/bone7/")
                || assetPath.Contains("art/model/bone/bone8/")
                || assetPath.Contains("art/model/bone/vehicle/")
                || assetPath.Contains("art/model/equip/"))
            {
                maxTexSize = 1024;
                string fileName = Path.GetFileNameWithoutExtension(assetPath);
                if (fileName.EndsWith("_a"))
                {
                    fileName = fileName.Substring(0, fileName.Length - 2);
                }

                if (fileName.EndsWith("_m") || fileName.EndsWith("_e"))
                {
                    maxTexSize = 256;
                }

                //                if (fileName.EndsWith("_s"))
                //                {
                //                    maxTexSize = 512;
                //                }
            }

            if (textureimport.assetPath.Contains("/effect/"))
            {
                maxTexSize = 256;
            }
            else
            {
                if (!textureimport.assetPath.Contains("/terrain/"))
                {
                    //                    textureimport.wrapMode = Set(textureimport.wrapMode, TextureWrapMode.Clamp, ref needSave);
                }
            }

            if (textureimport.assetPath.Contains("/terrain/"))
            {
                maxTexSize = 2048;
            }

            //          if (textureimport.assetPath.Contains("/terrain/custom/"))
            //          {
            //              return false;
            //          }

            if (textureimport.assetPath.Contains("/custom/"))
            {
                return false;
            }

            if (textureimport.assetPath.Contains("/terrain/texture/"))
            {
                maxTexSize = 1024;
            }

            else if (textureimport.assetPath.EndsWith(".exr") && textureimport.assetPath.Contains("/terrain/sky"))
            {
                maxTexSize = 256;
            }

            maxTexSize = Mathf.Min(maxTexSize, setting.maxTextureSize);

            if(textureimport.assetPath.Contains("props083_001_e.jpg"))
            {
                Debug.LogError("testtest1: " + newA +"  |" + setting.name + " | " + textureimport.assetPath + "  " + setting.maxTextureSize + "  " + maxTexSize);
            }

            setting.maxTextureSize = Set(setting.maxTextureSize, maxTexSize, ref needSave);

            TextureImporterFormat format = TextureImporterFormat.Automatic;
            if ((textureimport.assetPath.EndsWith(".png") || textureimport.assetPath.Contains("_a.") || textureimport.assetPath.Contains("_a_")) && textureimport.DoesSourceTextureHaveAlpha())
            {
                if (platform == "Android")
                {
                    format = TextureImporterFormat.ETC2_RGBA8;
                }
                else if (platform == "iPhone")
                {
                    format = TextureImporterFormat.PVRTC_RGBA4;
                }
                else if (platform == "Standalone")
                {
                    //                    format = TextureImporterFormat.RGBA32;
                }
            }
            else //if (assetPath.EndsWith(".jpg"))
            {
                if (platform == "Android")
                {
                    format = TextureImporterFormat.ETC_RGB4;
                }
                else if (platform == "iPhone")
                {
                    format = TextureImporterFormat.PVRTC_RGB4;
                }
                else if (platform == "Standalone")
                {
                    //                    format = TextureImporterFormat.RGB24;
                    //                    format = TextureImporterFormat.RGBA32;
                }
            }


            setting.format = Set(setting.format, format, ref needSave);
            if (needSave)
            {
                if(textureimport.assetPath.Contains("props083_001_e.jpg"))
                {
                    Debug.LogError("testtest2: " + newA +"  |" + setting.name + " | " + textureimport.assetPath + "  " + setting.maxTextureSize + "  " + maxTexSize);
                }

                textureimport.SetPlatformTextureSettings(setting);
            }
        }



        return needSave;
    }

//     [MenuItem("Assets/Custom/Texture/FixTextureProperty")]
//     static void FixTextureProperty()
//     {
//         EditorCommonTool.ProcessSelectionObjs("*", (path) =>
//             {
//                 ImportAsset(path);
//             });
//     }

//     [MenuItem("Assets/Custom/ModelTool/SimplifySkinnedMeshEquipPrefab")]
//     static void SimplifySkinnedMeshEquipPrefab()
//     {
//         EditorCommonTool.ProcessSelectionObjs("*.prefab", (path) =>
//             {
//                 SimplifySkinnedMeshEquipPrefab(path);
//             });

//         AssetDatabase.SaveAssets();
//         AssetDatabase.Refresh();
//     }

//     public static void SimplifySkinnedMeshEquipPrefab(string path)
//     {
//         GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
//         SkinnedMeshRenderer renderer = prefab.GetComponentInChildren<SkinnedMeshRenderer>();
//         if(renderer == null)
//         {
//             return;
//         }

//         if(renderer.gameObject == prefab)
//         {
//             return;
//         }

//         GameObject obj = GameObject.Instantiate(prefab);
//         renderer = obj.GetComponentInChildren<SkinnedMeshRenderer>();
//         renderer.transform.SetParent(null);
//         GameObject.DestroyImmediate(obj);


//         PrefabUtility.ReplacePrefab(renderer.gameObject, prefab, ReplacePrefabOptions.Default);
//         GameObject.DestroyImmediate(renderer.gameObject);
//     }

    static bool fixUI(TextureImporter textureimport)
    {
        if (textureimport == null)
        {
            return false;
        }

        bool needSave = false;
        TextureImporterSettings tis = new TextureImporterSettings();
        textureimport.ReadTextureSettings(tis);//先read 再 set

        tis.textureType = Set(tis.textureType, TextureImporterType.Sprite, ref needSave);
        tis.spriteMeshType = Set(tis.spriteMeshType, SpriteMeshType.FullRect, ref needSave);
        if (needSave)
        {
            textureimport.SetTextureSettings(tis);
        }

        textureimport.sRGBTexture = Set(textureimport.sRGBTexture, true, ref needSave);
        textureimport.alphaSource = Set(textureimport.alphaSource, TextureImporterAlphaSource.FromInput, ref needSave);
        textureimport.alphaIsTransparency = Set(textureimport.alphaIsTransparency, true, ref needSave);
        textureimport.filterMode = Set(textureimport.filterMode, FilterMode.Bilinear, ref needSave);
        textureimport.spriteImportMode = Set(textureimport.spriteImportMode, SpriteImportMode.Single, ref needSave);
        textureimport.mipmapEnabled = Set(textureimport.mipmapEnabled, false, ref needSave);
        textureimport.isReadable = Set(textureimport.isReadable, false, ref needSave);
        //        textureimport.wrapMode = Set(textureimport.wrapMode, TextureWrapMode.Clamp, ref needSave);
        textureimport.npotScale = Set(textureimport.npotScale, TextureImporterNPOTScale.None, ref needSave);

        return needSave;
    }

//     // [MenuItem("Assets/UITex ByJson")]
//     // static void fixUIByJson()
//     // {
//     //     var selected = Selection.activeObject;
//     //     var jsonPath = AssetDatabase.GetAssetPath(selected);
//     //     if (!jsonPath.EndsWith(".json"))
//     //         return;
//     //     //添加Extra Transforms to Expose
//     //     AnimationClipConfig.getJsonUIBorder(jsonPath);
//     //     UIBorderRoot uiborderroot = AnimationClipConfig.uiborderroot;
//     //     List<string> listPath = new List<string>();
//     //     if (uiborderroot != null && uiborderroot.strpath != null && uiborderroot.strpath.Count > 0)
//     //     {
//     //         for (int j = 0; j < uiborderroot.strpath.Count; j++)
//     //         {
//     //             UIBorderItem item = uiborderroot.strpath[j];
//     //             if (item.path != "")
//     //             {
//     //                 TextureImporter textureImporter = AssetImporter.GetAtPath(ResourcesEx.BundleResDir + "/tex/"+item.path) as TextureImporter;
//     //                 if(textureImporter !=null)
//     //                 {
//     //                     // X = left, Y = bottom, Z = right, W = top.
//     //                     textureImporter.spriteBorder = new Vector4(item.left, item.bottom, item.right, item.top);
//     //                     AssetDatabase.ImportAsset(item.path);
//     //                 }
//     //             }
//     //         }
//     //     }
//     // }

//     public static void SetTexToSolidColor(Color32 c)
//     {
//         float scale = 1f;

//         for(int i = 0; i < Selection.assetGUIDs.Length; i++)
//         {
//             string p = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[i]);

//             string[] paths = null;
//             if(Directory.Exists(p))
//             {
//                 paths = Directory.GetFiles(p, "*", SearchOption.TopDirectoryOnly);
//             }
//             else
//             {
//                 paths = new string[]{p};
//             }

//             for(int j = 0; j < paths.Length; j++)
//             {
//                 string texPath = paths[j];
//                 if(!texPath.EndsWith("jpg") && !texPath.EndsWith("png"))
//                 {
//                     continue;
//                 }

//                 string ext = Path.GetExtension(texPath);

//                 Dictionary<string, TempTextureFormat> dic = MaterialTextureForETC1.SetTextureReadable(texPath);

//                 Texture2D tex = AssetDatabase.LoadAssetAtPath(texPath, typeof(Texture2D)) as Texture2D;
//                 TextureImporter textureImporter = AssetImporter.GetAtPath (texPath) as TextureImporter;
//                 Vector4 border = textureImporter.spriteBorder;

//                 int tw =  tex.width;
//                 int th =  tex.height;

//                 Color32[] data = tex.GetPixels32();
//                 int e = data.Length;
//                 Resources.UnloadAsset(tex);
//                 MaterialTextureForETC1.ReverseTextureReadable(texPath, dic);

//                 int newTw = Mathf.RoundToInt(tw * scale);
//                 int newTh = Mathf.RoundToInt(th * scale);

//                 float densityx = (float)tw / newTw;
//                 float densityy = (float)th / newTh;
//                 Color32[] newPixel = new Color32[newTw * newTh];

//                 for(int u = 0; u < newTh; u++)
//                 {
//                     for(int v = 0; v < newTw; v++)
//                     {
//                         float le = v * densityx;
//                         float ri = le + densityx;
//                         float bo = u * densityy;
//                         float to = bo + densityy;




//                         int sumr = 0;
//                         int sumg = 0;
//                         int sumb = 0;
//                         int suma = 0;


//                         //                  for(int b = (int)bo; b < to; b++)
//                         //                  {
//                         //                      for(int l = (int)le; l < ri; l++)
//                         //                      {
//                         //                          float fx = Mathf.Min(ri - l, 1);
//                         //                          if(l <= le && Mathf.Abs(l - le) < fx)
//                         //                          {
//                         //                              fx = 1 - Mathf.Abs(l - le);
//                         //                          }
//                         //                          
//                         //                          float fy = Mathf.Min(to - b, 1);
//                         //                          if(b <= bo && Mathf.Abs(b - bo) < fy)
//                         //                          {
//                         //                              fy = 1 - Mathf.Abs(b - bo);
//                         //                          }
//                         //                          
//                         //                          Color32 temp = data[l + b * tw];
//                         //                          sumr += Mathf.RoundToInt(fx * fy * temp.r);
//                         //                          sumg += Mathf.RoundToInt(fx * fy * temp.g);
//                         //                          sumb += Mathf.RoundToInt(fx * fy * temp.b);
//                         //                          suma += Mathf.RoundToInt(fx * fy * temp.a);
//                         //                      }
//                         //                  }

//                         float factor = densityx * densityy;
//                         byte nr = (byte)Mathf.RoundToInt(sumr / factor);
//                         byte ng = (byte)Mathf.RoundToInt(sumg / factor);
//                         byte nb = (byte)Mathf.RoundToInt(sumb / factor);
//                         byte na = (byte)Mathf.RoundToInt(suma / factor);
//                         newPixel[u * newTw + v] = c;
//                     }
//                 }

//                 TextureFormat format = TextureFormat.RGBA32;
//                 if(ext == ".jpg")
//                 {
//                     format = TextureFormat.RGB24;
//                 }

//                 Texture2D newTex = new Texture2D(newTw, newTh, format, false);
//                 newTex.SetPixels32(newPixel);
//                 byte[] newData = null;
//                 if(ext == ".png")
//                 {
//                     newData = newTex.EncodeToPNG();
//                 }
//                 else
//                 {
//                     newData = newTex.EncodeToJPG();
//                 }

//                 GameObject.DestroyImmediate(newTex);


//                 //          CommonUtil.bytesToFile(CommonUtil.addSuffixToFileName(texPath, "_test"), newData);

//                 CommonUtil.bytesToFile(texPath, newData);
//                 border.x = Mathf.RoundToInt(border.x * ((float)newTw / tw));
//                 border.z = Mathf.RoundToInt(border.z * ((float)newTw / tw));
//                 border.y = Mathf.RoundToInt(border.y * ((float)newTh / th));
//                 border.w = Mathf.RoundToInt(border.w * ((float)newTh / th));
//                 textureImporter = AssetImporter.GetAtPath (texPath) as TextureImporter;
//                 textureImporter.spriteBorder = border;
//             }
//         }
//         AssetDatabase.Refresh();
//     }

//     [MenuItem("Assets/Custom/Texture/WhiteTex")]
//     public static void WhiteTex()
//     {
//         SetTexToSolidColor(new Color(255, 255, 255, 255));
//     }

//     [MenuItem("Assets/Custom/Texture/BlackTex")]
//     public static void BlackTex()
//     {
//         SetTexToSolidColor(new Color(0, 0, 0, 0));
//     }

//     [MenuItem("Assets/Custom/Texture/LinearTex")]
//     public static void LinearTex()
//     {
//         Texture2D tex = new Texture2D(1024, 1024, TextureFormat.RGB24, false);
//         for (int i = 0; i < tex.width; i++)
//         {
//             float v = (float)i / (tex.width - 1);
//             Color c = new Color(v, v, v, 1);
//             for (int j = 0; j < tex.height; j++)
//             {
//                 tex.SetPixel(i, j, c);
//             }
//         }

//         byte[] data = tex.EncodeToPNG();
//         CommonUtil.bytesToFile("linear.png", data);
//     }

//     [MenuItem("Assets/Custom/Texture/GammaTex")]
//     public static void GammaTex()
//     {
//         Texture2D tex = new Texture2D(1024, 1024, TextureFormat.RGB24, false);
//         for (int i = 0; i < tex.width; i++)
//         {
//             float v = (float)i / (tex.width - 1);
//             v = Mathf.Pow(v, 2.2f);
//             Color c = new Color(v, v, v, 1);
//             for (int j = 0; j < tex.height; j++)
//             {
//                 tex.SetPixel(i, j, c);
//             }
//         }

//         byte[] data = tex.EncodeToPNG();
//         CommonUtil.bytesToFile("gamma.png", data);
//     }

//     [MenuItem("Assets/Custom/Texture/SetSpriteBorder")]
//     public static void SetSpriteBorder()
//     {
//         Dictionary<Sprite, Vector4> spriteSet = new Dictionary<Sprite, Vector4>();
//         EditorCommonTool.ProcessSelectionObjs("*.prefab", (path) => 
//             {
//                 GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
//                 UI2DSprite[] uiSprites = prefab.GetComponentsInChildren<UI2DSprite>();
//                 for(int i = 0; i < uiSprites.Length; i++)
//                 {
//                     UI2DSprite uiSprite = uiSprites[i];
//                     if(uiSprite.sprite2D != null)
//                     {
//                         if(uiSprite.border != uiSprite.sprite2D.border)
//                         {
//                             Vector4 existedBorder = Vector4.zero;
//                             if(spriteSet.TryGetValue(uiSprite.sprite2D, out existedBorder))
//                             {
//                                 //                                if(uiSprite.border != existedBorder)
//                                 //                                {
//                                 //                                    throw new System.Exception("difference border: " + uiSprite.sprite2D.name + "  " + uiSprite.border + "  " + existedBorder);
//                                 //                                }
//                                 continue;
//                             }

//                             spriteSet.Add(uiSprite.sprite2D, uiSprite.border);
//                         }
//                     }
//                 }
//             });

//         string log = "";
//         foreach (var entry in spriteSet)
//         {
//             log += AssetDatabase.GetAssetPath(entry.Key) + "\n";

//             TextureImporter texImporter = TextureImporter.GetAtPath(AssetDatabase.GetAssetPath(entry.Key)) as TextureImporter;
//             texImporter.spriteBorder = entry.Value;
//             texImporter.SaveAndReimport();
//         }

//         if (!string.IsNullOrEmpty(log))
//         {
//             Debug.LogError(log);
//         }
//     }

//     static Dictionary<string, string> TestAmiibo2(string dirPath)
//     {
//         Dictionary<string, string> map = new Dictionary<string, string>();
//         string[] paths = System.IO.Directory.GetFiles(dirPath, "*.bin", SearchOption.AllDirectories);
//         for (int i = 0; i < paths.Length; i++)
//         {
//             string path = paths[i];

//             string md5 = MD5Hash.GetMD5HashFromFile(path);
//             if (!map.ContainsKey(md5))
//             {
//                 map.Add(md5, path);
//             }
//         }

//         return map;
//     }


//     [MenuItem("Custom/AssetTool/FixWritableTexture")]
//     public static void FixWritableTexture()
//     {
//         //        string p = "Assets/terrain/model/park/fountainContainer01_s.png";
//         //        byte[] d = SetTextureReadable(p);
//         //        ReverseTextureReadable(p, d);
//         //        return;

//         HashSet<string> retPaths = new HashSet<string>();
//         HashSet<string> paths = EditorCommonTool.FindAssets("Assets", "t:texture");
//         foreach(string path in paths)
//         {
//             //            string content = CommonUtil.fileToString(path + ".meta");
//             //
//             //            if(path == "Assets/BundleRes/tex/ui/equip/21403_show.png")
//             //            {
//             //                CommonUtil.stringToFile("content.txt", content);
//             //            }

//             //            if (content.Contains("isReadable: 1\n"))
//             //            {
//             ////                content = content.Replace("isReadable: 1\n", "isReadable: 0\n");
//             ////                CommonUtil.stringToFile(path + ".meta", content);
//             //                retPaths.Add(path);
//             //            }


//             AssetImporter tempImporter = TextureImporter.GetAtPath(path);
//             IHVImageFormatImporter ihvImageFormatImporter = tempImporter as IHVImageFormatImporter;
//             //            UnityEngine.NativeFormatImporter nativeFormatImporter = tempImporter as UnityEngine.NativeFormatImporter;
//             TextureImporter importer = tempImporter as TextureImporter;
//             if (importer == null)
//             {
//                 Debug.LogError("importer is null: " + path + "   " + tempImporter);
//             }

//             if (importer != null && (importer.isReadable || importer.mipmapEnabled))
//             {
//                 retPaths.Add(importer.assetPath);

//                 if (!path.Contains("Assets/framework/third_party") && !path.Contains("Assets/third_party") && !path.Contains("Assets/ShaderForge"))
//                 {
//                     bool needSave = false;
//                     if (importer.isReadable)
//                     {
//                         importer.isReadable = false;
//                         needSave = true;
//                     }


//                     if (!path.Contains("Assets/terrain/custom/tile") && importer.mipmapEnabled && importer.textureShape != TextureImporterShape.TextureCube)
//                     {
//                         importer.mipmapEnabled = false;
//                         needSave = true;
//                     }

//                     if (needSave)
//                     {
//                         importer.SaveAndReimport();
//                     }
//                 }
//             }
//             else if (ihvImageFormatImporter != null && ihvImageFormatImporter.isReadable)
//             {
//                 retPaths.Add(ihvImageFormatImporter.assetPath);

//                 if (!path.Contains("Assets") || path.Contains("Assets/T4MOBJ"))
//                 {
//                     ihvImageFormatImporter.isReadable = false;
//                     ihvImageFormatImporter.SaveAndReimport();
//                 }
//             }
//         }

//         string log = "";
//         foreach (string path in retPaths)
//         {
//             log += path + "\n";
//         }
//         CommonUtil.stringToFile("writable_tex.txt", log);
//     }


//     //    public static bool IsTexHasAlpha(Texture tex)
//     //    {
//     //        if(tex != null)
//     //        {
//     //            string bumpTexPath = AssetDatabase.GetAssetPath(tex);
//     //            TextureImporter importer = TextureImporter.GetAtPath(bumpTexPath) as TextureImporter;
//     //            return importer.DoesSourceTextureHaveAlpha();
//     //        }
//     //
//     //        return false;
//     //    }

//     public static HashSet<string> GetAllAssetsByFilter(string filter)
//     {
//         HashSet<string> assetPathSet = EditorCommonTool.FindAssets("Assets/BundleRes");

//         for (int i = 0; i < EditorBuildSettings.scenes.Length; i++)
//         {
//             EditorBuildSettingsScene scene = EditorBuildSettings.scenes[i];
//             assetPathSet.Add(scene.path);
//         }

//         string[] dependencies = AssetDatabase.GetDependencies(assetPathSet.ToArray(), true);
//         HashSet<string> matPathSet = new HashSet<string>();
//         for(int i = 0; i < dependencies.Length; i++)
//         {
//             string d = dependencies[i];
//             if(d.EndsWith(filter))
//             {
//                 matPathSet.Add(d);
//             }
//         }

//         return matPathSet;
//     }

//     [MenuItem("Custom/AssetTool/ResetParticleSystemTrailMaterial")]
//     public static void ResetParticleSystemTrailMaterial()
//     {
//         HashSet<string> multiMatPsSet = new HashSet<string>();
//         HashSet<string> matPathSet = GetAllAssetsByFilter(".prefab");
//         foreach(string p in matPathSet)
//         {
//             GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(p);
//             ParticleSystem[] particles = prefab.GetComponentsInChildren<ParticleSystem>(true);
//             for(int j = 0; j < particles.Length; j++)
//             {
//                 var t = particles[j];
//                 ParticleSystemRenderer r = t.GetComponent<ParticleSystemRenderer>();
//                 if(!t.trails.enabled)
//                 {
//                     r.trailMaterial = null;
//                 }
//             }
//         }

//         CommonUtil.ObjectToJsonFile(multiMatPsSet, "multi_mat_particle_prefab.txt");
//     }

//     [MenuItem("Custom/AssetTool/DisableImportMaterialofFBX")]
//     public static void DisableImportMaterialofFBX()
//     {
//         HashSet<string> multiMatPsSet = new HashSet<string>();
//         HashSet<string> matPathSet = GetAllAssetsByFilter(".fbx");
//         HashSet<string> matPathSet2 = GetAllAssetsByFilter(".FBX");
//         matPathSet.Add(matPathSet2);

//         foreach(string p in matPathSet)
//         {
//             ModelImporter mi = AssetImporter.GetAtPath(p) as ModelImporter;
//             mi.importMaterials = false;
//             mi.SaveAndReimport();
//         }

//         CommonUtil.ObjectToJsonFile(multiMatPsSet, "fbx.txt");
//     }

//     [MenuItem("Custom/AssetTool/CheckLodMats")]
//     public static void CheckLodMats()
//     {
//         HashSet<string> s = new HashSet<string>();
//         HashSet<string> matPathSet = GetAllAssetsByFilter(".mat");
//         foreach(var matPath in matPathSet)
//         {
//             if(!matPath.Contains("Assets/lod/"))
//             {
//                 continue;
//             }

//             Material mat = AssetDatabase.LoadAssetAtPath<Material>(matPath);
//             if(mat.shader.name.Contains("Standard"))
//             {

//                 Texture2D specTex = null;
//                 if(mat.HasProperty("_SpecGlossMap"))
//                 {
//                     specTex = mat.GetTexture("_SpecGlossMap") as Texture2D;
//                 }

//                 Texture2D bumpTex = null;
//                 if(mat.HasProperty("_BumpMap"))
//                 {
//                     bumpTex = mat.GetTexture("_BumpMap") as Texture2D;
//                 }

//                 Texture2D emisTex = null;
//                 if(mat.HasProperty("_EmissionMap"))
//                 {
//                     emisTex = mat.GetTexture("_EmissionMap") as Texture2D;
//                 }

//                 if(specTex != null || emisTex != null || bumpTex != null)
//                 {
//                     s.Add(matPath);
//                 }
//             }
//         }

//         var b = s.ToArray();
//         System.Array.Sort(b);
//         CommonUtil.ObjectToJsonFile(b, "error_mat_paths.txt");
//     }

    

//     [MenuItem("Custom/AssetTool/ScaleAllTexture")]
//     public static void ScaleAllTexture()
//     {
//         HashSet<string> allAssetPaths = new HashSet<string>();

//         string[] prefabPaths = new string[]{"Assets/BundleRes/art", "Assets/BundleRes/terrain"};
// //        string[] prefabPaths = new string[]{"Assets/BundleRes/img_font"};
//         for(int i = 0; i < prefabPaths.Length; i++)
//         {
//             string prefabPath = prefabPaths[i];
//             string[] filePaths = System.IO.Directory.GetFiles(prefabPath, "*", SearchOption.AllDirectories);

//             allAssetPaths.Add(AssetDatabase.GetDependencies(filePaths));
//         }

//         string diff = CommonUtil.fileToString("diff.txt");
//         string[] usedPaths = diff.Split('\n');
//         HashSet<string> usedPathSet = new HashSet<string>(usedPaths);

//         foreach(var s in allAssetPaths)
//         {
//             string filePath = s;
//             if(usedPathSet.Contains(filePath))
//             {
//                 continue;
//             }

//             string ext = System.IO.Path.GetExtension(filePath);
//             if(ext == ".prefab" || ext == ".mat" || ext == ".asset")
//             {
//                 continue;
//             }

//             Texture2D tex = AssetDatabase.LoadAssetAtPath<Texture2D>(filePath);
//             if(tex != null)
//             {
//                 int width = tex.width / 2;
//                 int height = tex.height / 2;

//                 width = Mathf.Min(width, height);

//                 if(width < 32)
//                 {
//                     width = 32;

//                     if(tex.width == width || tex.height == width)
//                     {
//                         continue;
//                     }
//                 }

//                 Resources.UnloadAsset(tex);
//                 tex = null;

//                 TextureImporter ti = AssetImporter.GetAtPath(filePath) as TextureImporter;

//                 {
//                     TempTextureFormat androidFormat = new TempTextureFormat();
//                     bool ret = ti.GetPlatformTextureSettings("Android", out androidFormat.maxSize, out androidFormat.format, out androidFormat.quality);
//                     ti.SetPlatformTextureSettings("Android", width, androidFormat.format, androidFormat.quality, false);
//                 }

//                 {
//                     TempTextureFormat androidFormat = new TempTextureFormat();
//                     bool ret = ti.GetPlatformTextureSettings("iPhone", out androidFormat.maxSize, out androidFormat.format, out androidFormat.quality);
//                     ti.SetPlatformTextureSettings("iPhone", width, androidFormat.format, androidFormat.quality, false);
//                 }

//                 ti.SaveAndReimport();
//             }
//         }
//     }


//     [MenuItem("Custom/AssetTool/ScaleAllTextureIos")]
//     public static void ScaleAllTextureIos()
//     {
//         HashSet<string> allAssetPaths = new HashSet<string>();

//         string[] prefabPaths = new string[]{"Assets/BundleRes/art", "Assets/BundleRes/terrain"};
//         //        string[] prefabPaths = new string[]{"Assets/BundleRes/img_font"};
//         for(int i = 0; i < prefabPaths.Length; i++)
//         {
//             string prefabPath = prefabPaths[i];
//             string[] filePaths = System.IO.Directory.GetFiles(prefabPath, "*", SearchOption.AllDirectories);

//             allAssetPaths.Add(AssetDatabase.GetDependencies(filePaths));
//         }

//         string diff = CommonUtil.fileToString("diff.txt");
//         string[] usedPaths = diff.Split('\n');
//         HashSet<string> usedPathSet = new HashSet<string>(usedPaths);

//         foreach(var s in allAssetPaths)
//         {
//             string filePath = s;
// //            if(usedPathSet.Contains(filePath))
// //            {
// //                continue;
// //            }

//             string ext = System.IO.Path.GetExtension(filePath);
//             if(ext == ".prefab" || ext == ".mat" || ext == ".asset" || ext.ToLower() == ".fbx" || ext.ToLower() == ".obj")
//             {
//                 continue;
//             }

//             TextureImporter ti = AssetImporter.GetAtPath(filePath) as TextureImporter;
//             if(ti != null)
//             {
                


//                 TempTextureFormat androidFormat = new TempTextureFormat();
//                 bool ret = ti.GetPlatformTextureSettings("Android", out androidFormat.maxSize, out androidFormat.format, out androidFormat.quality);

//                 TempTextureFormat iosFormat = new TempTextureFormat();
//                 ti.GetPlatformTextureSettings("iPhone", out iosFormat.maxSize, out iosFormat.format, out iosFormat.quality);
//                 if(iosFormat.maxSize > androidFormat.maxSize)
//                 {
//                     ti.SetPlatformTextureSettings("iPhone", androidFormat.maxSize, iosFormat.format, iosFormat.quality, false);
//                     ti.SaveAndReimport();
//                 }
//             }
//         }
//     }

    public static void EmptyFunction()
    {
        
    }
}

